home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 426-450 / disk_429 / uedit-stuff / delete < prev    next >
Text File  |  1992-05-06  |  15KB  |  363 lines
  1. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  2. *** Uedit scratch-delete functions which remember the last eight deletes
  3. ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  4.  
  5. n28 contains the number of the buffer that holds the newest cut.  This gets
  6. bumped by virtual-kp7 just before the cut is made, if it isn't merging with
  7. the last one.  To change the range of buffers that is used to store cut
  8. pieces (currently 80 to 87), you only need to change three commands:  the
  9. ring rotating commands lAmiga-kp4 and lAmiga-kp6, and the general deleting
  10. engine virtual-kp7, at the lines where the comment says "Bounds".  If you
  11. want to change the n-vars used, you'll have to change lots of commands.
  12.  
  13. n27 is the buffer the last cut was made in, or -1 if any paste has been made
  14. since the last cut.  It is -2 after ctl-kp0 if it was nonnegative before,
  15. which means don't merge the next cut, but don't allow operations that work on
  16. the last paste either (lamiga-kp1, lamiga-kp0).
  17.  
  18. General scratch deleter - decide whether to merge, then move locA-locB to ring
  19. <virtual-kp7:   if (eqnum(n27, curfile))  .. shall we merge? last cut was here
  20.                     if (not eqloc(curfile, locA, mouseloc))     .. mouseloc is
  21.                         if (not eqloc(curfile, locB, mouseloc)) ..   old locB
  22.                             equatenum(n27, -2)                  .. no
  23.                 equatenum(n54, n28)      .. ** for virtual-kp4 split display
  24.                 if (not eqnum(n27, curfile)) {                  .. un-merge:
  25.                     if (genum(80, n28)) equatenum(n28, 87)      .. Bounds
  26.                     else decnum(n28)
  27.                     freeBuf(buf[n28])
  28.                 } else if (gtnum(80, n28)) equatenum(n28, 87)   .. Bounds
  29.                 if (eqloc(curfile, mouseloc, locA))         .. front or back?
  30.                     insertrgn(buf[n28], efile, curfile, loc)
  31.                 else insertrgn(buf[n28], sfile, curfile, loc)
  32.                 equateloc(buf[n28], spage, sfile)               .. cosmetic
  33.                 clearrgn(curfile, loc)  .. mustn't forget to actually delete!
  34.                 if (genum(n54, 80))             .. ** Bounds
  35.                     runkey(virtual-kp4)         .. ** update split window
  36.                 equatenum(n27, curfile)
  37. >
  38. Those lines marked with ** can be removed for speed if desired.  They
  39. cause a split window made with lamiga-1 to be updated in real time as you
  40. delete things.
  41.  
  42. Show top of delete ring in split window
  43. <lamiga-1:      equatenum(n54, curfile)
  44.                 if (not eqnum(curfile, n28)) if (not gotosplit(buf[n28])) {
  45.                     splitwindow(buf[n28], splitsize)
  46.                     gotosplit(buf[n54])  .. not curfile unless press it again
  47.                 }
  48.                 putmsg("Use lAmiga-kp4 and lAmiga-kp6 to rotate ring")
  49. >
  50.  
  51. *** HERE'S THE SIMPLE VERSION that leaves the split window curfile ***
  52. Show top of delete ring in split window
  53. .. <lamiga-1:   if (not eqnum(curfile, n28)) if (not gotosplit(buf[n28]))
  54.                     splitwindow(buf[n28], splitsize)
  55.                 putmsg("Use lAmiga-kp4 and lAmiga-kp6 to rotate ring")
  56. >
  57.  
  58. Push back newest entry on scratch delete ring
  59. <lamiga-kp4:    equatenum(n54, n28)
  60.                 if (genum(n28, 87)) equatenum(n28, 80)          .. Bounds
  61.                 else incnum(n28)
  62.                 runkey(virtual-kp4)
  63. >
  64.  
  65. Pull forward oldest entry on scratch delete ring
  66. <lamiga-kp6:    equatenum(n54, n28)
  67.                 if (genum(80, n28)) equatenum(n28, 87)          .. Bounds
  68.                 else decnum(n28)
  69.                 runkey(virtual-kp4)
  70. >
  71.  
  72. Display correct buffer in top-of-delete-ring split window
  73. <virtual-kp4:   if (eqnum(curfile, n54)) editbuf(buf[n28])
  74.                 else {
  75.                     equatenum(n53, curfile)
  76.                     if (gotosplit(buf[n54])) {
  77.                         editbuf(buf[n28])
  78.                         gotosplit(buf[n53])
  79.                     }
  80.                 }
  81. >
  82.  
  83. Undo last paste (kp0), hopefully only when it was just done
  84. <lamiga-kp0:    if (not eqnum(n27, -1)) {
  85.                     putmsg("No paste since last cut")
  86.                     returnfalse
  87.                 }
  88.                 if (not eqloc(curfile, atcursor, locB)) {
  89.                     putmsg("Can't un-paste -- wrong location")
  90.                     returnfalse
  91.                 }
  92.                 clearrgn(curfile, loc)
  93.                 equatenum(n27, curfile)
  94. >
  95.  
  96. Go to location of last scratch delete or undo
  97. <lamiga-kp5:    movecursor(curfile, locB) >
  98.  
  99. Go to top end of last scratch undo, or maybe anywhere
  100. <lamiga-kp8:    if (not eqnum(n27, -1)) putmsg("No paste since last cut")
  101.                 else movecursor(curfile, locA)
  102. >
  103.  
  104. Undo latest scratch delete, inserting at cursor, marking with loc
  105. <normal-kp0:    if (eqnum(n28, 0)) return               .. no cut since start!
  106.                 equateloc(curfile, locA, atcursor)
  107.                 if (eqloc(curfile, atcursor, sfile)) {
  108.                     insertrgn(curfile, sfile, buf[n28], all)
  109.                     equateloc(curfile, locA, sfile)
  110.                 } else {
  111.                     equateloc(curfile, locA, atcursor)
  112.                     decloc(curfile, locA)
  113.                     insertRgn(curFile,atCursor,buf[n28],all)
  114.                     incloc(curfile, locA)
  115.                 }
  116.                 equateloc(curfile, locB, atcursor)
  117.                 equatenum(n27, -1)
  118.                 if (thiskey)
  119.                     if (eqloc(curfile, atcursor, spage)) {  .. don't you hate it
  120.                         vscroll(atcursor)                   .. when the pasted-in
  121.                         updatedisplay                       .. text is offscreen?
  122.                     }
  123. >
  124.  
  125. Set search string, using text of last cut
  126. <shftaltctl-f7: freebuf(buf49)
  127.                 insertrgn(buf49, sfile, buf[n28], all)
  128.                 putmsg("Input search string:")
  129.                 inputstring(buf49)
  130.                 setsearch(buf49)
  131.                 runkey(normal-f9)
  132. >
  133.  
  134. Replace last paste with older cut, hopefully only when it was just done
  135. <lamiga-kp1:    if (runkey(lamiga-kp0)) {
  136.                     runkey(lamiga-kp4)
  137.                     runkey(normal-kp0)
  138.                 }
  139. >
  140.  
  141. Prevent next delete from merging with the previous one
  142. <ctl-kp0:       if (genum(n27, 0)) equatenum(n27, -2)  >
  143.  
  144. Delete word left, storing it in Undo buffer
  145. <normal-kp7:    equateloc(curfile, mouseloc, locB)
  146.                 equateloc(curfile, locB, atcursor)
  147.                 movecursor(curfile, sword)
  148.                 equateloc(curfile, locA, atcursor)
  149.                 runkey(virtual-kp7)
  150. >
  151.  
  152. Delete word right, storing it in Undo buffer
  153. <normal-kp9:    equateloc(curfile, mouseloc, locB)
  154.                 equateloc(curfile, locA, atcursor)
  155.                 movecursor(curfile, eword)
  156.                 equateloc(curfile, locB, atcursor)
  157.                 runkey(virtual-kp7)
  158. > 
  159.  
  160. Delete char to left of cursor, storing it in Undo buffer
  161. <shft-kp7:      equateloc(curfile, mouseloc, locB)
  162.                 equateloc(curfile, locB, atcursor)
  163.                 movecursor(curfile, schar)
  164.                 equateloc(curfile, locA, atcursor)
  165.                 runkey(virtual-kp7)
  166. >
  167.  
  168. Delete char under cursor, storing it in Undo buffer
  169. <shft-kp9:      equateloc(curfile, mouseloc, locB)
  170.                 equateloc(curfile, locA, atcursor)
  171.                 movecursor(curfile, echar)
  172.                 equateloc(curfile, locB, atcursor)
  173.                 runkey(virtual-kp7)
  174. > 
  175.  
  176. Delete to start of line, storing it in Undo buffer
  177. <alt-kp7:       if (is(curFile,sLine)) runKey(shft-kp7)
  178.                 else {
  179.                     equateloc(curfile, mouseloc, locB)
  180.                     equateloc(curfile, locB, atcursor)
  181.                     movecursor(curfile, sline)
  182.                     equateloc(curfile, locA, atcursor)
  183.                     runkey(virtual-kp7)
  184.                 }
  185. >
  186.  
  187. Delete to end of line, storing it in Undo buffer
  188. <alt-kp9:       if (is(curFile,eLine)) runKey(shft-kp9)
  189.                 else {
  190.                     equateloc(curfile, mouseloc, locB)
  191.                     equateloc(curfile, locA, atcursor)
  192.                     movecursor(curfile, eline)
  193.                     equateloc(curfile, locB, atcursor)
  194.                     runkey(virtual-kp7)
  195.                 }
  196. >
  197.  
  198.   Personally, I don't use these next two, they're too accident-prone.
  199.  
  200. Delete from cursor to start of window, storing it in Undo buffer
  201. <ctl-kp7:       equateloc(curfile, mouseloc, locB)
  202.                 equateloc(curfile, locB, atcursor)
  203.                 movecursor(curfile, spage)
  204.                 equateloc(curfile, locA, atcursor)
  205.                 runkey(virtual-kp7)
  206.                 vscroll(atcursor)
  207.                 updatedisplay
  208. >
  209.  
  210. Delete from cursor to end of window, storing it in Undo buffer
  211. <ctl-kp9:       equateloc(curfile, mouseloc, locB)
  212.                 equateloc(curfile, locA, atcursor)
  213.                 movecursor(curfile, epage)
  214.                 equateloc(curfile, locB, atcursor)
  215.                 runkey(virtual-kp7)
  216.                 vscroll(atcursor)
  217.                 updatedisplay
  218. >
  219.  
  220. Delete cursor line
  221. <virtual-x:     equateLoc(curFile, mouseLoc, locB)
  222.                 if (not is(curFile,sLine)) moveCursor(curFile,sLine)
  223.                 equateloc(curfile, locA, atcursor)
  224.                 if (not is(curFile,eLine)) moveCursor(curFile,eLine)
  225.                 moveCursor(curFile,eChar)
  226.                 equateLoc(curFile,locB,atCursor)
  227.                 runkey(virtual-kp7)
  228. >
  229.  
  230. (redundant with standard config)
  231. UNDO newest scratch delete, inserting at cursor
  232. <alt-kp0:       runKey(normal-kp0) >
  233. UNDO newest scratch delete, inserting at cursor
  234. <shft-kp0:      runKey(normal-kp0) >
  235.  
  236. Delete cursor line, storing it in Undo buffer.  (See keypad-0/7/9.)
  237. <ctl-d:   runKey(virtual-x) >
  238.  
  239. Delete line above cursor line
  240. <ctl-del:  locToCol(curfile, n50, atCursor)
  241.            if (moveCursor(curFile,upLine)) {
  242.                runKey(virtual-x)                .. this deletes the line
  243.                colToLoc(curfile, atCursor, n50)
  244.            }
  245. >
  246.  
  247. Delete line below cursor line
  248. <ctl-bs: locToCol(curfile, n50, atcursor)
  249.          if (moveCursor(curFile,downLine)) {
  250.              runKey(virtual-x)          .. this deletes the line
  251.              moveCursor(curFile,upLine)
  252.              colToLoc(curfile, atCursor, n50)
  253.          }
  254. >
  255.  
  256. Delete from cursor back to most recent occurence of character
  257. <lamiga-kp7:    putmsg("What character should mark the start of the delete?")
  258.                 getchar(n0)
  259.                 equateloc(curfile, mouseloc, locB)
  260.                 equateloc(curfile, locB, atcursor)
  261.                 decloc(curfile, atcursor) .. skip first character
  262.                 equatenum(n1, -1)
  263.                 if (runkey(virtual-/)) {
  264.                     movecursor(curfile, echar)
  265.                     equateloc(curfile, locA, atcursor)
  266.                     runkey(virtual-kp7)
  267.                     putmsg(" ")
  268.                 } else {
  269.                     movecursor(curfile, locB)
  270.                     equateloc(curfile, locB, mouseloc)
  271.                     putmsg("Not found.")
  272.                 }
  273.                 setsearch(buf53)
  274. >
  275.  
  276. Delete from cursor to next occurence of a given character
  277. <lamiga-kp9:    putmsg("What character should mark the end of the delete?")
  278.                 getchar(n0)
  279.                 equateloc(curfile, mouseloc, locB)
  280.                 equateloc(curfile, locB, atcursor)
  281.                 equatenum(n1, 1)
  282.                 if (runkey(virtual-/)) {
  283.                     equateloc(curfile, locA, locB)  .. swap ends
  284.                     equateloc(curfile, locB, atcursor)
  285.                     runkey(virtual-kp7)
  286.                     putmsg(" ")
  287.                 } else {
  288.                     equateloc(curfile, locB, mouseloc)
  289.                     putmsg("Not found.")
  290.                 }
  291.                 setsearch(buf53)
  292. >
  293.  
  294. Search for single char n0 in direction n1, trashing locA, using your searchCaps
  295. <virtual-/:     freebuf(buf54)
  296.                 insertchar(buf54, "\\")
  297.                 insertchar(buf54, n0)
  298.                 freebuf(buf53)
  299.                 getsearch(buf53)
  300.                 setsearch(buf54)
  301.                 search(curfile, locA, locA, n1)  .. don't care which
  302. > returns true or false depending on search             end locA ends up on
  303.  
  304. Extend the last scratch delete to cursor in either direction
  305. <lamiga-kp3:    if (gtloc(curfile, atcursor, locB)) {
  306.                     equateloc(curfile, locA, locB)
  307.                     equateloc(curfile, locB, atcursor)
  308.                     equateloc(curfile, mouseloc, locA)
  309.                 } else {
  310.                     equateloc(curfile, locA, atcursor)
  311.                     equateloc(curfile, mouseloc, locB)
  312.                 }
  313.                 runkey(virtual-kp7)
  314. >
  315.  
  316. Delete back to end of indent whitespace
  317. <shftalt-kp7:   loctocol(curfile, n51, atcursor)
  318.                 if (not runkey(ctl-[)) returnfalse      .. ctl-[ is missing!
  319.                 if (gtnum(n51, n50)) {
  320.                     equateloc(curfile, mouseloc, locB)
  321.                     equateloc(curfile, locA, atcursor)
  322.                     coltoloc(curfile, atcursor, n51)
  323.                     equateloc(curfile, locB, atcursor)
  324.                     runkey(virtual-kp7)
  325.                 } else coltoloc(curfile, atcursor, n51)
  326. >
  327.  
  328. Delete from cursor to start of paragraph (last blank line)
  329. <shftctl-kp7:   equateloc(curfile, mouseloc, locB)
  330.                 equateloc(curfile, locB, atcursor)
  331.                 while (decloc(curfile, atcursor))
  332.                     if (is(curfile, whitespace)) goto label (47)
  333.             label (47)
  334.                 while (movecursor(curfile, upline))
  335.                     if (is(curfile, blankline)) {
  336.                         movecursor(curfile, downline)
  337.                         if (not is(curfile, sline)) movecursor(curfile, sline)
  338.                         goto label (1)
  339.                     }
  340.                 movecursor(curfile, sfile)
  341.             label (1)
  342.                 equateloc(curfile, locA, atcursor)
  343.                 runkey(virtual-kp7)
  344. >
  345.  
  346. Delete from cursor to end of paragraph (next blank line)
  347. <shftctl-kp9:   equateloc(curfile, mouseloc, locB)
  348.                 equateloc(curfile, locA, atcursor)
  349.                 while (incloc(curfile, atcursor))
  350.                     if (is(curfile, whitespace)) goto label (47)
  351.             label (47)
  352.                 while (movecursor(curfile, downline))
  353.                     if (is(curfile, blankline)) {
  354.                         if (not is(curfile, sline)) movecursor(curfile, sline)
  355.                         movecursor(curfile, schar)
  356.                         goto label (1)
  357.                     }
  358.                 movecursor(curfile, efile)
  359.             label (1)
  360.                 equateloc(curfile, locB, atcursor)
  361.                 runkey(virtual-kp7)
  362. >
  363.